9 research outputs found
Complete and efficient methods for supporting side effects in independent/restricted and-parallelism
It has been shown that it is possible to exploit Independent/Restricted And-parallelism in logic programs while retaining the conventional "don't know" semantics of such programs. In particular, it is possible to parallelize
pure Prolog programs while maintaining the semantics of the
language. However, when builtin side-effects (such as write or assert) appear in the program, if an identical observable behaviour to that of sequential Prolog implementations is to be preserved, such side-effects have
to be properly sequenced. Previously proposed solutions to this problem are either incomplete (lacking, for example, backtracking semantics) or they force sequentialization of significant portions of the execution graph which could otherwise run in parallel. In this paper a series of side-effect synchronization methods are proposed which incur lower overhead and allow more parallelism than those previously proposed. Most importantly, and unlike previous proposals, they have well-defined backward execution behaviour and require only a small modification to a given
(And-parallel) Prolog implementation
Combined determination of sharing and freeness of program variables through abstract interpretation
In this paper, abstract interpretation algorithms are described for computing the sharmg as well as the freeness information about the run-time instantiations of program variables. An abstract domain is proposed which accurately and concisely represents combined freeness and sharing information for program variables. Abstract unification and all other domain-specific functions for an abstract interpreter working on this domain are presented. These functions are illustrated with an example. The importance of inferring freeness is stressed by showing (1) the central role it plays in non-strict goal independence, and (2) the improved accuracy it brings to the analysis of sharing information when both are computed together. Conversely, it is shown that keeping accurate track of sharing allows more precise inference of freeness, thus resulting in an overall much more powerful abstract interpreter
The CDG, UDG, and MEL methods for automatic compile-time parallelization of logic programs for independent and-parallelism
There has been significant interest in parallel execution models for logic programs which exploit Independent And-Parallelism (IAP). In these models, it is necessary to determine which goals are independent and therefore eligible
for parallel execution and which goals have to wait for which others during execution. Although this can be done at run-time, it can imply a very heavy overhead. In this paper, we present three algorithms for automatic compiletime
parallelization of logic programs using IAP. This is done by converting a clause into a graph-based computational form and then transforming this graph into linear expressions based on &-Prolog, a language for IAP. We also present an algorithm which, given a clause, determines if there is any loss of parallelism due to linearization, for the case in which only unconditional parallelism is desired. Finally, the performance of these annotation algorithms is discussed for some benchmark programs
Deriving a fixpoint computation algorithm for top-down abstract interpretation of logic programs
Bruynooghe described a framework for the top-down abstract interpretation of logic programs. In this framework, abstract interpretation is carried out by constructing an abstract and-or tree in a top-down fashion for a given query and program. Such an abstract interpreter requires fixpoint computation for programs which contain recursive predicates. This paper presents in detail a fixpoint algorithm that has been developed for this purpose and the motivation behind it. We start off by describing a simple-minded algorithm. After pointing out its shortcomings, we present a series of refinements to this algorithm, until we reach the final version. The aim is to give an intuitive grasp and provide justification for the relative complexity of the final algorithm. We also present an informal proof of correctness of the algorithm and some results obtained from an implementation
Determination of variable dependence information through abstract interpretation
Traditional schemes for abstract interpretation-based global analysis of logic programs generally focus on obtaining procedure argument mode and type information. Variable sharing information is often given only the attention needed to preserve the correctness of the analysis. However, such sharing information can be very useful. In particular, it can be used for predicting run-time goal independence, which can eliminate costly run-time checks in and-parallel execution. In this paper, a new algorithm for doing abstract interpretation in logic programs is described which infers the dependencies of the terms bound to program variables with increased precisión and at all points in the execution of the program, rather than just at a procedure level. Algorithms are presented for computing abstract entry and success substitutions
which extensively keep track of variable aliasing and term dependence information. The algorithms are illustrated with examples
Determination of variable dependence information at compile-time through abstract interpretation
Traditional schemes for abstract interpretation-based global analysis of logic
programs generally focus on obtaining procedure argument mode and type
information. Variable sharing information is often given only the attention
needed to preserve the correctness of the analysis. However, such sharing
information can be very useful. In particular, it can be used for predicting
run-time goal independence, which can eliminate costly run-time checks in
and-parallel execution. In this paper, a new algorithm for doing abstract
interpretation in logic programs is described which infers the dependencies
of the terms bound to program variables with increased precision and at all
points in the execution of the program, rather than just at a procedure level.
Algorithms are presented for computing abstract entry and success substitutions which extensively keep track of variable aliasing and term dependence
information. The algorithms are illustrated with examples
Determination of variable dependence information at compile-time through abstract interpretation
Traditional schemes for abstract interpretation-based global analysis of logic
programs generally focus on obtaining procedure argument mode and type
information. Variable sharing information is often given only the attention
needed to preserve the correctness of the analysis. However, such sharing
information can be very useful. In particular, it can be used for predicting
run-time goal independence, which can eliminate costly run-time checks in
and-parallel execution. In this paper, a new algorithm for doing abstract
interpretation in logic programs is described which infers the dependencies
of the terms bound to program variables with increased precision and at all
points in the execution of the program, rather than just at a procedure level.
Algorithms are presented for computing abstract entry and success substitutions which extensively keep track of variable aliasing and term dependence
information. The algorithms are illustrated with examples
A Compiler Framework for Restructuring Data Declarations to Enhance Cache and TLB Effectiveness
It has been observed that memory access performance can be improved by restructuring data declarations, using simple transformations such as array dimension padding and inter-array padding (array alignment) to reduce the number of misses in the cache and TLB (translation lookaside buffer). These transformations can be applied to both static and dynamic array variables. In this paper, we provide a padding algorithm for selecting appropriate padding amounts, which takes into account various cache and TLB effects collectively within a single framework. In addition to reducing the number of misses, we identify the importance of reducing the impact of cache miss jamming by spreading cache misses more uniformly across loop iterations. We translate undesirable cache and TLB behaviors into a set of constraints on padding amounts and propose a heuristic algorithm of polynomial time complexity to find the padding amounts to satisfy these constraints. The goal of the padding algorithm is to sele..